home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / online / source / cpp / graphics / Conics.sit.hqx / Conics / Class Libraries / Cleanup / Cleanup.cpp next >
Text File  |  1996-11-08  |  6KB  |  174 lines
  1. //Copyright 1996 Aidan Cully
  2. //All rights reserved
  3.  
  4. #include <Dialogs.h>
  5. #include "Cleanup.h"
  6.  
  7. TCleanup mainClean;
  8.  
  9. void DrawAlert( unsigned char *theText ) {
  10.     ::ParamText( theText, 0l, 0l, 0l );
  11.     Alert( 128, 0l );
  12. }
  13.  
  14. //    TCleanup::RegisterDirtyAction()
  15. //    uses:
  16. //        Use this procedure to place a procedure in the procedure list which will be called
  17. //        after two conditions are met:
  18. //            1: that an action is pending in the "Dirty" list (normally this occurs through
  19. //             calls to "NotifyDirty", which must be called after "RegisterDirtyAction"
  20. //            2: that Clean be called.  This can be called from anywhere, but will most likely
  21. //             be called (depending on the variable you use for cleanup) every time through the
  22. //             the event loop.
  23. //    in:
  24. //        UInt32 procID: a unique ID number which is forever bound to the second parameter
  25. //        CleanupProc theProc: a procedure which takes a void* and a procID as parameters, and
  26. //         performs some action or other based on these datas.
  27. //    return value:
  28. //        UInt8: an error code.  Current possibilities are:
  29. //            kSuccess == No Error
  30. //            kDuplicateActionErr == the procID variable is already in use
  31. //            kCleanupMemErr == out of memory
  32. UInt8 TCleanup::RegisterDirtyAction( UInt32 procID, CleanupProc theProc ) {
  33.     ProcType *theEl;
  34.  
  35.     //if nothing is in the procedure list as yet, then insert the first element.
  36.     if( !procs.MoveFirst() ) {
  37.         //create and initialize the element structure.  We need to have an element structure
  38.         //because of the *extremely* rudimentary way in which TList operates.
  39.         theEl = new ProcType;
  40.         if( !theEl )
  41.             return( kCleanupMemErr );
  42.         theEl->procID = procID;
  43.         theEl->theProc = theProc;
  44.         if( !procs.AddNext() )
  45.             return( kCleanupMemErr );
  46.         procs.SetData( (UInt32)theEl );
  47.         return( kSuccess );
  48.     } else { //otherwise, we have to check that the procID variable is actually unique before
  49.              //inserting.
  50.         //the if block above called upon entry "procs.MoveFirst()," so we don't have to bother
  51.         //here.
  52.         UInt32 temp;
  53.         do {    //loop through every element in the list to find possibly duplicate procID's.
  54.             procs.GetData( temp );
  55.             theEl = (ProcType*)temp;
  56.             if( theEl->procID == procID )    //Found one?
  57.                 return( kDuplicateActionErr );    //then return the error code.
  58.         } while( procs.MoveNext() );
  59.         //create the new variables (in the TList, and in the ProcType*) checking for memory
  60.         //allocation errors.
  61.         if( !procs.AddNext() )
  62.             return( kCleanupMemErr );
  63.         //now, everything's fine.
  64.         theEl = new ProcType;
  65.         if( !theEl )
  66.             return( kCleanupMemErr );
  67.         theEl->procID = procID;
  68.         theEl->theProc = theProc;
  69.         procs.SetData( (UInt32)theEl );
  70.         return( kSuccess );
  71.     }
  72. }
  73.  
  74. //    TCleanup::NotifyDirty()
  75. //    uses:
  76. //        Use NotifyDirty to have a function called with certain data the next time Clean() is
  77. //        called for this particular instance of TCleanup.
  78. //    in:
  79. //        UInt32 procID: unique ID number identifying which procedure to call
  80. //        void *procData: data to be used locally by said procedure
  81. //    return value:
  82. //        UInt8: possible return values are at present:
  83. //            kSuccess == everything's groovin.
  84. //            kActionNotFoundErr == the procID specified is invalid.
  85. //            kCleanupMemErr == out of memory.
  86. UInt8 TCleanup::NotifyDirty( UInt32 procID, void *procData ) {
  87.     DataType *theEl;
  88.     ProcType *procEl;
  89.     Boolean found = false;
  90.  
  91.     //Verify that a procedure IS identified by procID.
  92.     if( !procs.MoveFirst() )
  93.         return( kActionNotFoundErr );
  94.     UInt32 temp;
  95.     do {
  96.         procs.GetData( temp );
  97.         procEl = (ProcType*)temp;
  98.         if( procEl->procID == procID )
  99.             found = true;
  100.     } while( !found && procs.MoveNext() );
  101.     if( !found )
  102.         return( kActionNotFoundErr );
  103.     //The procedure does exist, now add an element to the stack signifying that this procedure
  104.     //must be called with this particular data.
  105.     theEl = new DataType;
  106.     if( !theEl )
  107.         return( kCleanupMemErr );
  108.     theEl->procID = procID;
  109.     theEl->procData = procData;
  110.     if( !queue.Enqueue( (UInt32)theEl ) )
  111.         return( kCleanupMemErr );
  112.     //Wow, everything went fine!
  113.     return( kSuccess );
  114. }
  115.  
  116. //    TCleanup::Clean()
  117. //    uses:
  118. //        Use this procedure to call all other procedures that the TCleanup object has been told
  119. //        to call (usually by use of the NotifyDirty() procedure).
  120. //    in: none.
  121. //    return value:
  122. //        UInt8: the return value can be (at present) one of the following:
  123. //            kSuccess == Far Out in a Happening Kind of Way (™)
  124. //            kActionNotFound == one of the elements in the list had no appropriate action.
  125. //            kActionLocalErr == the action procedure called had some kind of problem with it.
  126. UInt8 TCleanup::Clean() {
  127.     DataType *theEl;
  128.     ProcType *theProc;
  129.     UInt32 temp;
  130.     Boolean found;
  131.  
  132.     while( queue.Dequeue( temp ) ) {
  133.         theEl = (DataType*) temp;
  134.         if( !procs.MoveFirst() )
  135.             return( kActionNotFoundErr );
  136.         found = false;
  137.         do {
  138.             procs.GetData( temp );
  139.             theProc = (ProcType*)temp;
  140.             if( theProc->procID == theEl->procID )
  141.                 found = true;
  142.             else if( !procs.MoveNext() ) {
  143.                 delete theEl;
  144.                 return( kActionNotFoundErr );
  145.             }
  146.         } while( !found );
  147.         if( !theProc->theProc( theEl->procID, theEl->procData ) ) {
  148.             delete theEl;
  149.             return( kActionLocalErr );
  150.         }
  151.         delete theEl;
  152.     }
  153.     return( kSuccess );
  154. }
  155.  
  156. //    TCleanup::~TCleanup()
  157. //    Destroys all variables associated with TCleanup.  DOES NOT call the action procedures (at
  158. //    this point, that could even be dangerous).
  159. TCleanup::~TCleanup() {
  160.     ProcType *theProc;
  161.     DataType *theData;
  162.     UInt32 dataInt;
  163.  
  164.     if( procs.MoveFirst() )
  165.         do {
  166.             procs.GetData( dataInt );
  167.             theProc = (ProcType*)dataInt;
  168.             delete theProc;
  169.         } while( procs.Remove() );
  170.     while( queue.Dequeue( dataInt ) ) {
  171.         theData = (DataType*)dataInt;
  172.         delete theData;
  173.     }
  174. }